import AMapWX from '@/utils/amap-wx.130.js';
import {
	GD_key
} from '@/config/common.js'
import {
	polygonsData
} from '@/utils/polygonsData.js'

let amapPlugin = {}
// #ifdef MP-WEIXIN
amapPlugin = new AMapWX({
	key: GD_key
});
// #endif
export async function getLocation() {
	return new Promise((resolve, reject) => {
		// #ifdef MP-WEIXIN
		wx.getLocation({
			altitude: false, //传入 true 会返回高度信息，由于获取高度需要较高精确度，会减慢接口返回速度
			isHighAccuracy: true, //开启高精度定位
			// wx.getFuzzyLocation({
			type: 'gcj02',
			success: (res) => {
				console.log(res)
				let {
					latitude,
					longitude
				} = res
				// reverseGeocoder(latitude, longitude).then(result => {
				// 	resolve({
				// 		latitude,
				// 		longitude,
				// 		...result
				// 	})
				// }).catch(e => {
				// 	reject(e)
				// })
				reversGecoder_GD(latitude, longitude /* 30.547040,104.062880 */ ).then(
					result => {
						resolve(result)
					}).catch(e => {
					console.log(e)
					reject(e)
				})
			},
			fail(e) {
				reject('获取经纬度信息失败')
			}
		})
		// #endif
	})

}
//调用高德地图逆地理编码 API
async function reversGecoder_GD(latitude, longitude) {
	return new Promise((resolve, reject) => {
		amapPlugin.getRegeo({
			location: `${longitude},${latitude}`,
			success: (data) => {
				console.log(data)
				let address = data[0];
				let {
					addressComponent
				} = address.regeocodeData ?? {}
				resolve({
					latitude,
					longitude,
					desc: address.desc,
					name: address.name,
					street: address?.regeocodeData?.addressComponent?.streetNumber
						?.street || '',
					formatted_address: address?.regeocodeData?.formatted_address || '',
				})
			},
			fail: function(info) {
				//失败回调
				reject(info)
			}
		});

	})

}

// 调用腾讯地图逆地理编码 API
async function reverseGeocoder(latitude, longitude) {
	const key = 'ZW3BZ-H4RLW-SHHRV-YJ4NU-BXIV2-5DF7Q'; // 替换为你的腾讯地图 Key
	const url = `https://apis.map.qq.com/ws/geocoder/v1/?location=${latitude},${longitude}&key=${key}`;

	const response = await uni.request({
		url,
		method: "GET"
	});
	if (response.data.status === 0) {
		return response.data.result // 返回推荐地址
	} else {
		throw new Error('逆地理编码失败');
	}
}

/**
 * 判断定位权限是否打开
 */
export const authorization = () => {
	let authouName = "定位服务"
	// 1、判断手机定位服务【GPS】 是否授权
	uni.getSystemInfo({
		success(res) {
			console.log("判断手机定位服务是否授权:", res);
			let locationEnabled = res.locationEnabled; //判断手机定位服务是否开启
			let locationAuthorized = res.locationAuthorized; //判断定位服务是否允许微信授权
			if (locationEnabled == false) {
				//手机定位服务（GPS）未授权
				uni.showToast({
					title: "请打开手机GPS",
					icon: "none",
				});
			} else if (locationAuthorized == false) {
				//#ifdef H5 || APP-PLUS
				uni.showToast({
					title: "请先授权定位服务",
					icon: "none",
				});
				//#endif
				// #ifdef MP-WEIXIN
				uni.showToast({
					title: "请先授权定位服务是否允许微信",
					icon: "none",
				});
				//#endif

			} else {
				//手机定位服务（GPS）已授权
				// 2、判断微信小程序是否授权位置信息
				// 微信小程序已授权位置信息
				// #ifdef MP-WEIXIN
				uni.authorize({
					//授权请求窗口
					scope: "scope.userLocation", //授权的类型
					success: (res) => {
						console.log('success:', res)
					},
					fail: (err) => {
						console.log('err:', err)
						err = err["errMsg"];
						uni
							.showModal({
								content: "需要授权位置信息",
								confirmText: "确认授权",
							})
							.then((res) => {
								console.log(res);
								if (res[1]["confirm"]) {
									uni.openSetting({
										success: (res) => {
											if (res.authSetting[
													"scope.userLocation"]) {
												// 授权成功
												uni.showToast({
													title: "授权成功",
													icon: "none",
												});

											} else {
												// 未授权
												uni.showToast({
													title: "授权失败,请重新授权",
													icon: "none",
												});
												uni.showModal({
													title: "授权",
													content: "获取授权" +
														authouName +
														"失败,是否前往授权设置？",
													success: function(
														result) {
														if (result
															.confirm
														) {
															uni
																.openSetting();
														}
													},
													fail: function() {
														uni.showToast({
															title: "系统错误！",
															icon: "none",
														});
													},
												});
											}
										},
									});
								}
								if (res[1]["cancel"]) {
									// 取消授权
									uni.showToast({
										title: "你拒绝了授权，无法获得周边信息",
										icon: "none",
									});
								}
							});
					},
					complete(res) {
						// console.log('授权弹框', res);
						if (res.errMsg == "authorize:ok") {

						} else {
							uni.showModal({
								title: "授权",
								content: "获取授权" + authouName + "失败,是否前往授权设置？",
								success: function(result) {
									if (result.confirm) {
										uni.openSetting();
									}
								},
								fail: function() {
									uni.showToast({
										title: "系统错误！",
										icon: "none",
									});
								},
							});
						}
					},
				});
				//#endif
			}
		},
	});
	//#ifdef H5 || APP-PLUS

	//#endif
	// #ifdef MP-WEIXIN

	//#endif
}

/**
 * 判断某一个 经纬度是否属于某一个区域范围内
 * @param {Object} point - 目标点 { latitude, longitude }
 * @param {Array} polygons - 多边形区域 [{ latitude, longitude }, ...]
 * @returns {boolean} - 是否在外接矩形内
 */
function isPointInBoundingBox(point, polygons) {
	let minLat = polygons[0].latitude;
	let maxLat = polygons[0].latitude;
	let minLng = polygons[0].longitude;
	let maxLng = polygons[0].longitude;

	// 计算多边形的外接矩形
	polygons.forEach(({
		latitude,
		longitude
	}) => {
		minLat = Math.min(minLat, latitude);
		maxLat = Math.max(maxLat, latitude);
		minLng = Math.min(minLng, longitude);
		maxLng = Math.max(maxLng, longitude);
	});

	// 判断点是否在外接矩形内
	return (
		point.latitude >= minLat &&
		point.latitude <= maxLat &&
		point.longitude >= minLng &&
		point.longitude <= maxLng
	);
}
/**
 * 判断点是否在多边形内
 * @param {Object} point - 目标点 { latitude, longitude }
 * @param {Array} polygons - 多边形区域 [{ latitude, longitude }, ...]
 * @returns {boolean} - 是否在多边形内
 */
function isPointInPolygon(point, polygons) {
	const {
		latitude,
		longitude
	} = point;
	let inside = false;

	for (let i = 0, j = polygons.length - 1; i < polygons.length; j = i++) {
		const {
			latitude: lat1,
			longitude: lng1
		} = polygons[i];
		const {
			latitude: lat2,
			longitude: lng2
		} = polygons[j];

		// 检查点是否在多边形的纬度范围内
		const intersect =
			lat1 > latitude !== lat2 > latitude &&
			longitude < ((lng2 - lng1) * (latitude - lat1)) / (lat2 - lat1) + lng1;

		if (intersect) {
			inside = !inside;
		}
	}

	return inside;
}

/**
 * 判断点是否在多边形内（优化版）
 */
export function isPointInPolygonOptimized(point) {
	const polygons = polygonsData.points.map(val => {
		return {
			latitude: val[1],
			longitude: val[0]
		}
	})
	// 先判断是否在外接矩形内
	if (!isPointInBoundingBox(point, polygons)) {
		return false;
	}

	// 再使用射线交叉算法判断
	return isPointInPolygon(point, polygons);
}